package handlers

import (
	"encoding/json"
	"net/http"
	"shopback/models"
	"strconv"

	"log"

	"github.com/gorilla/mux"
)

// Register 用户注册
    // @Summary 用户注册
    // @Description 注册一个新用户，包括用户名、密码和邮箱的验证及存储。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param user body models.User true "用户信息"
    // @Success 201 {string} string "用户注册成功"
    // @Failure 400 {string} string "请求参数错误"
    // @Failure 409 {string} string "用户名或邮箱已存在"
    // @Failure 500 {string} string "服务器内部错误"
    // @Router /register [post]
func Register(w http.ResponseWriter, r *http.Request) {
    // 接受前端的 JSON 数据
    var RegisterRequest struct {
        Username    string `json:"username"`
        Password    string `json:"password"`
        Phonenumber string `json:"phonenumber"`
        Email       string `json:"email"`
    }

    if err := json.NewDecoder(r.Body).Decode(&RegisterRequest); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    // 在终端打印所有注册信息
    log.Printf("收到前端注册信息：\n    username：%s \n    password：%s \n    phonenumber：%s \n    email：%s", RegisterRequest.Username, RegisterRequest.Password, RegisterRequest.Phonenumber, RegisterRequest.Email)

    // 检查用户名是否已存在
    existingUser, err := models.GetUserByUsername(RegisterRequest.Username)
    if err == nil && existingUser.Username != "" {
        // 将错误信息封装成一个 JSON 对象，并返回给前端："用户名已存在"
        // http.Error(w, "用户名已存在", http.StatusBadRequest)
        response := map[string]string{"error": "用户名已存在"}
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(response)

        log.Printf("用户名" + RegisterRequest.Username + "已存在")
        return
    }

    // 检查手机号是否已存在
    existingPhonenumber, err := models.GetUserByPhonenumber(RegisterRequest.Phonenumber)
    if err == nil && existingPhonenumber.Phonenumber != "" {
        // http.Error(w, "手机号已存在", http.StatusBadRequest)
        response := map[string]string{"error": "手机号已存在"}
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(response)

        log.Printf("手机号" + RegisterRequest.Phonenumber + "已存在")
        return
    }

    // 检查邮箱是否已存在
    existingEmail, err := models.GetUserByEmail(RegisterRequest.Email)
    if err == nil && existingEmail.Email != "" {
        // http.Error(w, "邮箱已存在", http.StatusBadRequest)
        response := map[string]string{"error": "邮箱已存在"}
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(response)
        
        log.Printf("邮箱" + RegisterRequest.Email + "已存在")
        return
    }

    // 确认无疑后，创建新用户
    user := models.User{
        Username:    RegisterRequest.Username,
        Password:    RegisterRequest.Password,
        Phonenumber: RegisterRequest.Phonenumber,
        Email:       RegisterRequest.Email,
    }

    // 调用模型层的 AddUser 函数将用户添加到数据库
    _, err = models.AddUser(user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]string{"message": "用户注册成功"})
}

// Login 用于用户登录
    // @Summary 用户登录
    // @Description 登录系统，需要用户名和密码。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param login body models.User{Username string `json:"username"`; Password string `json:"password"`} true "登录信息"
    // @Success 200 {string} string "登录成功", "token":"fake-jwt-token"
    // @Failure 400 {string} string "请求参数错误"
    // @Failure 401 {string} string "无效的用户名或密码"
    // @Router /login [post]
func Login(w http.ResponseWriter, r *http.Request) {
	var loginData struct {
		Username string `json:"username"`
		Password string `json:"password"`
	}

	if err := json.NewDecoder(r.Body).Decode(&loginData); err != nil {
		w.Header().Set("Content-Type", "application/json")
		http.Error(w, `{"message": "无效的请求数据"}`, http.StatusBadRequest)
		return
	}

	// 验证用户名和密码
	user, err := models.AuthenticateUser(loginData.Username, loginData.Password)
	if err != nil {
		w.Header().Set("Content-Type", "application/json")
		http.Error(w, `{"message": "用户名或密码错误"}`, http.StatusUnauthorized)
		return
	}

	// 登录成功
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"message": "登录成功",
		"user": map[string]interface{}{
			"id":          user.ID,
			"username":    user.Username,
			"email":       user.Email,
			"phonenumber": user.Phonenumber,
		},
	})
}

// GetUser 用于根据用户 ID 获取用户信息
    // @Summary 获取用户信息
    // @Description 根据用户ID获取用户详细信息。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param id path int true "用户ID"
    // @Success 200 {object} models.User "用户信息"
    // @Failure 400 {string} string "无效用户ID"
    // @Failure 404 {string} string "用户未找到"
    // @Failure 500 {string} string "服务器内部错误"
    // @Router /users/{id} [get]
func GetUser(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idStr := vars["id"]

	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "无效用户ID", http.StatusBadRequest)
		return
	}

	user, err := models.GetUserByID(id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(user)
}

// UpdateUser 用于更改用户账户及其相关数据
    // UpdateUser 更改用户
    // @Summary 更改用户
    // @Description 根据用户ID更改用户账户及其相关数据。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param id path int true "用户ID"
    // @Param user body models.User true "用户更新信息"
    // @Success 200 {object} models.User "更新后的用户信息"
    // @Failure 400 {string} string "无效的请求数据"
    // @Failure 404 {string} string "用户未找到"
    // @Failure 500 {string} string "服务器内部错误"
    // @Router /users/{id} [put]
func UpdateUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    
    // 获取并验证用户ID
    vars := mux.Vars(r)
    id, err := strconv.Atoi(vars["id"])
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{"error": "无效的用户ID"})
        return
    }

    // 解析请求体
    var updateData models.User
    if err := json.NewDecoder(r.Body).Decode(&updateData); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{"error": "无效的请求数据"})
        return
    }

    // 更新用户信息
    updatedUser, err := models.UpdateUser(id, updateData)
    if err != nil {
        switch err.Error() {
        case "用户未找到":
            w.WriteHeader(http.StatusNotFound)
        default:
            w.WriteHeader(http.StatusInternalServerError)
        }
        json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
        return
    }

    // 返回更新后的用户信息
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(updatedUser)
}

// DeleteUser 用于删除用户账户及其相关数据
    // DeleteUser 删除用户
    // @Summary 删除用户
    // @Description 根据用户ID删除用户账户及其相关数据。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param id path int true "用户ID"
    // @Success 200 {string} string "用户删除成功"
    // @Failure 400 {string} string "无效用户ID"
    // @Failure 404 {string} string "用户未找到"
    // @Failure 500 {string} string "服务器内部错误"
    // @Router /users/{id} [delete]
func DeleteUser(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID, err := strconv.Atoi(vars["id"])
    if err != nil {
        // 返回合法的 JSON 格式错误消息
        http.Error(w, `{"message": "无效用户ID"}`, http.StatusBadRequest)
        return
    }

    // 调用 DeleteUser 删除用户
    rowsAffected, err := models.DeleteUser(userID)
    if err != nil {
        http.Error(w, `{"message": "服务器内部错误"}`, http.StatusInternalServerError)
        return
    }

    if rowsAffected == 0 {
        // 用户未找到，返回错误消息
        http.Error(w, `{"message": "用户未找到"}`, http.StatusNotFound)
        return
    }

    // 返回删除成功的响应
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]string{
        "message": "用户删除成功",
    })
}

// SendCode 发送验证码
    // SendCode 发送验证码
    // @Summary 发送验证码
    // @Description 根据用户提供的邮箱或手机号发送验证码。验证码可以用于后续的密码重置操作。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param admin body string true "邮箱或手机号"
    // @Success 200 {string} string "验证码发送成功"
    // @Failure 400 {string} string "无效的请求数据"
    // @Failure 400 {string} string "该邮箱或手机号不存在"
    // @Failure 500 {string} string "服务器内部错误"
    // @Router /send-code [post]
func SendCode(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	var req struct {
		Admin string `json:"admin"` // 邮箱或手机号
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]string{"error": "无效的请求数据"})
		return
	}

	// 验证用户是否存在
	exists, err := models.CheckUserExists(req.Admin)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
		return
	}
	if !exists {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]string{"error": "该邮箱或手机号不存在"})
		return
	}

	// 生成并保存验证码
	code, err := models.GenerateVerifyCode(req.Admin)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
		return
	}

	// 打印验证码用于测试
	log.Printf("Generated verification code for %s: %s", req.Admin, code)

	// 这里应该调用实际的短信/邮件服务发送验证码
	// 为了测试，我们直接返回成功
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]string{"message": "验证码发送成功"})
}

// ResetPassword 重置密码
    // @Summary 重置密码
    // @Description 根据提供的邮箱或手机号和验证码重置用户密码。
    // @Tags 用户
    // @Accept json
    // @Produce json
    // @Param admin body string true "邮箱或手机号"
    // @Param verify_code body string true "验证码"
    // @Param new_password body string true "新密码"
    // @Success 200 {string} string "密码重置成功"
    // @Failure 400 {string} string "无效的请求数据"
    // @Failure 400 {string} string "验证码错误"
    // @Failure 500 {string} string "服务器内部错误"
    // @Router /reset-password [post]
func ResetPassword(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	var req struct {
		Admin       string `json:"admin"`        // 邮箱或手机号
		VerifyCode  string `json:"verify_code"`  // 验证码
		NewPassword string `json:"new_password"` // 新密码
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]string{"error": "无效的请求数据"})
		return
	}

	// 验证验证码
	if err := models.VerifyCode(req.Admin, req.VerifyCode); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]string{"error": "验证码错误"})
		return
	}

	// 重置密码
	if err := models.ResetUserPassword(req.Admin, req.NewPassword); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
		return
	}

	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]string{"message": "密码重置成功"})
}
